import axios from 'axios';
import store from '../store/index.js';
import { ElMessage } from 'element-plus';
import router from '../router/index.js';

// 创建带智能参数处理的axios实例
const service = axios.create({
    baseURL: '',
    timeout: 150000,
    paramsSerializer: params => {
        // GET参数智能序列化（兼容空参和多参场景）
        const filteredParams = Object.keys(params)
            .filter(key => params[key] !== undefined && params[key] !== null)
            .reduce((acc, key) => {
                acc[key] = params[key];
                return acc;
            }, {});

        return Object.keys(filteredParams)
            .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(
                typeof filteredParams[key] === 'object'
                    ? JSON.stringify(filteredParams[key])
                    : filteredParams[key]
            )}`)
            .join('&');
    }
});

// 请求拦截器（强化规范处理）
service.interceptors.request.use(
    (config) => {
        // 认证令牌注入
        const token = store.getters.authToken;
        if (token) {
            config.headers['satoken'] = token;
        }

        // 特殊接口处理（分片上传）
        const isChunkUpload = config.url?.endsWith('/smartUpload');

        // GET请求处理
        if (config.method?.toLowerCase() === 'get') {
            // 空参数过滤（避免URL带?符号）
            if (Object.keys(config.params || {}).length === 0) {
                config.params = undefined;
            }
            // 默认表单编码（特殊接口除外）
            if (!isChunkUpload) {
                config.headers['Content-Type'] = 'application/x-www-form-urlencoded';
            }
        }
        // POST/PUT请求处理
        else if (['post', 'put'].includes(config.method?.toLowerCase())) {
            // 分片上传特殊处理
            if (isChunkUpload) {
                // 保留前端设置的multipart/form-data
                delete config.headers['Content-Type'];
            }
            // 普通JSON请求处理
            else if (!(config.data instanceof FormData)) {
                config.headers['Content-Type'] = 'application/json';
                // 自动序列化非FormData数据
                if (typeof config.data === 'object') {
                    config.data = JSON.stringify(config.data);
                }
            }
        }

        return config;
    },
    (error) => {
        return Promise.reject(error);
    }
);

// 响应拦截器（增强错误诊断）
service.interceptors.response.use(
    (response) => {
        const res = response.data;

        // 扩展业务状态码处理
        if (typeof res?.code === 'number' && res.code !== 200) {
            handleResponseErrors(res.code, res.msg || `业务异常（${res.code}）`);
            return Promise.reject(res);
        }
        return res;
    },
    (error) => {
        // 结构化错误对象
        const errorInfo = {
            status: error.response?.status,
            method: error.config?.method?.toUpperCase(),
            url: error.config?.url,
            code: error.code,
            timestamp: Date.now(),
            traceId: error.response?.headers?.['x-trace-id']
        };

        // 网络层错误处理
        if (!error.response) {
            const msg = error.message.includes('timeout')
                ? '请求超时，请检查网络连接'
                : '网络连接异常';
            ElMessage.error(msg);
            return Promise.reject({ ...errorInfo, type: 'NETWORK_ERROR', message: msg });
        }

        // 业务错误消息提取（兼容多种响应格式）
        const responseData = error.response.data || {};
        const errorMessage = responseData.msg
            || responseData.message
            || error.response.statusText;

        // HTTP状态码处理
        handleResponseErrors(error.response.status, errorMessage);

        return Promise.reject({
            ...errorInfo,
            data: responseData,
            type: 'HTTP_ERROR',
            message: errorMessage
        });
    }
);

// 错误处理模块
const handleResponseErrors = (code, message) => {
    const errorActions = {
        400: () => ElMessage.error(message || '服务操作异常'),
        401: () => {
            store.dispatch('logout');
            router.replace('/login?redirect=' + encodeURIComponent(router.currentRoute.value.fullPath))
                .then(() => {
                    ElMessage.error(message || '登录状态已过期');
                });
        },
        403: () => ElMessage.error(message || '缺少操作权限'),
        404: () => ElMessage.error(message || '资源不存在'),
        413: () => ElMessage.error('文件大小超过系统限制'),
        415: () => ElMessage.error('不支持的媒体类型'),
        500: () => ElMessage.error(message || '服务器内部异常'),
        502: () => ElMessage.error('网关错误，请稍后重试'),
        503: () => ElMessage.error('服务暂时不可用'),
        504: () => ElMessage.error('网关超时')
    };

    if (errorActions[code]) {
        errorActions[code]();
    } else {
        ElMessage.error(`请求错误（${code}）`);
    }
};

export default service;